/**
 * 登录注册相关的API服务
 */

import request from '~/api/request';
import {
  PasswordLoginRequest,
  CodeLoginRequest,
  RegisterRequest,
  SendCodeRequest,
  ResetPasswordRequest,
  ApiResponse,
  LoginResponse,
  SendCodeResponse,
  UserInfo,
  ApiPaths,
  StorageKeys
} from './types';

/**
 * 密码登录
 * @param data 登录数据
 * @returns 登录结果
 */
export async function passwordLogin(data: PasswordLoginRequest): Promise<ApiResponse<LoginResponse>> {
  try {
    const response = await request(ApiPaths.passwordLogin, 'POST', data);
    
    if (response.success) {
      // 保存token和用户信息
      await saveLoginInfo(response.data);
      // 保存登录方式
      wx.setStorageSync(StorageKeys.LOGIN_TYPE, 'password');
    }
    
    return response;
  } catch (error) {
    console.error('密码登录失败:', error);
    return {
      success: false,
      code: 500,
      message: '登录失败，请重试',
      data: null
    };
  }
}

/**
 * 验证码登录
 * @param data 登录数据
 * @returns 登录结果
 */
export async function codeLogin(data: CodeLoginRequest): Promise<ApiResponse<LoginResponse>> {
  try {
    const response = await request(ApiPaths.codeLogin, 'POST', data);
    
    if (response.success) {
      // 保存token和用户信息
      await saveLoginInfo(response.data);
      // 保存登录方式
      wx.setStorageSync(StorageKeys.LOGIN_TYPE, 'code');
    }
    
    return response;
  } catch (error) {
    console.error('验证码登录失败:', error);
    return {
      success: false,
      code: 500,
      message: '登录失败，请重试',
      data: null
    };
  }
}

/**
 * 用户注册
 * @param data 注册数据
 * @returns 注册结果
 */
export async function register(data: RegisterRequest): Promise<ApiResponse<LoginResponse>> {
  try {
    const response = await request(ApiPaths.register, 'POST', data);
    
    if (response.success) {
      // 注册成功后自动保存登录信息
      await saveLoginInfo(response.data);
      wx.setStorageSync(StorageKeys.LOGIN_TYPE, 'register');
    }
    
    return response;
  } catch (error) {
    console.error('注册失败:', error);
    return {
      success: false,
      code: 500,
      message: '注册失败，请重试',
      data: null
    };
  }
}

/**
 * 发送验证码
 * @param data 发送验证码数据
 * @returns 发送结果
 */
export async function sendVerifyCode(data: SendCodeRequest): Promise<ApiResponse<SendCodeResponse>> {
  try {
    const response = await request(ApiPaths.sendCode, 'POST', data);
    return response;
  } catch (error) {
    console.error('发送验证码失败:', error);
    return {
      success: false,
      code: 500,
      message: '发送验证码失败，请重试',
      data: null
    };
  }
}

/**
 * 验证验证码
 * @param phone 手机号
 * @param code 验证码
 * @returns 验证结果
 */
export async function verifyCode(phone: string, code: string): Promise<ApiResponse<any>> {
  try {
    const response = await request(ApiPaths.verifyCode, 'POST', { phone, code });
    return response;
  } catch (error) {
    console.error('验证码验证失败:', error);
    return {
      success: false,
      code: 500,
      message: '验证码验证失败',
      data: null
    };
  }
}

/**
 * 重置密码
 * @param data 重置密码数据
 * @returns 重置结果
 */
export async function resetPassword(data: ResetPasswordRequest): Promise<ApiResponse<any>> {
  try {
    const response = await request(ApiPaths.resetPassword, 'POST', data);
    return response;
  } catch (error) {
    console.error('重置密码失败:', error);
    return {
      success: false,
      code: 500,
      message: '重置密码失败，请重试',
      data: null
    };
  }
}

/**
 * 检查用户名是否可用
 * @param username 用户名
 * @returns 检查结果
 */
export async function checkUsername(username: string): Promise<ApiResponse<{ available: boolean }>> {
  try {
    const response = await request(ApiPaths.checkUsername, 'GET', { username });
    return response;
  } catch (error) {
    console.error('检查用户名失败:', error);
    return {
      success: false,
      code: 500,
      message: '检查用户名失败',
      data: { available: false }
    };
  }
}

/**
 * 检查手机号是否已注册
 * @param phone 手机号
 * @returns 检查结果
 */
export async function checkPhone(phone: string): Promise<ApiResponse<{ exists: boolean }>> {
  try {
    const response = await request(ApiPaths.checkPhone, 'GET', { phone });
    return response;
  } catch (error) {
    console.error('检查手机号失败:', error);
    return {
      success: false,
      code: 500,
      message: '检查手机号失败',
      data: { exists: true } // 出错时默认认为已存在，避免重复注册
    };
  }
}

/**
 * 获取用户信息
 * @returns 用户信息
 */
export async function getUserInfo(): Promise<ApiResponse<UserInfo>> {
  try {
    const response = await request(ApiPaths.getUserInfo, 'GET');
    
    if (response.success) {
      // 更新本地存储的用户信息
      wx.setStorageSync(StorageKeys.USER_INFO, response.data);
    }
    
    return response;
  } catch (error) {
    console.error('获取用户信息失败:', error);
    return {
      success: false,
      code: 500,
      message: '获取用户信息失败',
      data: null
    };
  }
}

/**
 * 退出登录
 * @returns 退出结果
 */
export async function logout(): Promise<ApiResponse<any>> {
  try {
    const response = await request(ApiPaths.logout, 'POST');
    
    // 清除本地存储
    clearLoginInfo();
    
    return response;
  } catch (error) {
    console.error('退出登录失败:', error);
    // 即使接口失败也清除本地存储
    clearLoginInfo();
    return {
      success: true,
      code: 200,
      message: '已退出登录',
      data: null
    };
  }
}

/**
 * 保存登录信息到本地存储
 * @param data 登录响应数据
 */
async function saveLoginInfo(data: LoginResponse): Promise<void> {
  try {
    // 保存token
    wx.setStorageSync(StorageKeys.ACCESS_TOKEN, data.token);
    
    // 保存用户信息
    if (data.userInfo) {
      wx.setStorageSync(StorageKeys.USER_INFO, data.userInfo);
    }
    
    console.log('登录信息已保存');
  } catch (error) {
    console.error('保存登录信息失败:', error);
  }
}

/**
 * 清除登录信息
 */
function clearLoginInfo(): void {
  try {
    wx.removeStorageSync(StorageKeys.ACCESS_TOKEN);
    wx.removeStorageSync(StorageKeys.USER_INFO);
    wx.removeStorageSync(StorageKeys.LOGIN_TYPE);
    console.log('登录信息已清除');
  } catch (error) {
    console.error('清除登录信息失败:', error);
  }
}

/**
 * 检查登录状态
 * @returns 是否已登录
 */
export function isLoggedIn(): boolean {
  try {
    const token = wx.getStorageSync(StorageKeys.ACCESS_TOKEN);
    return !!token;
  } catch (error) {
    console.error('检查登录状态失败:', error);
    return false;
  }
}

/**
 * 获取本地存储的用户信息
 * @returns 用户信息
 */
export function getLocalUserInfo(): UserInfo | null {
  try {
    const userInfo = wx.getStorageSync(StorageKeys.USER_INFO);
    return userInfo || null;
  } catch (error) {
    console.error('获取本地用户信息失败:', error);
    return null;
  }
}

/**
 * 获取本地存储的token
 * @returns token
 */
export function getLocalToken(): string | null {
  try {
    const token = wx.getStorageSync(StorageKeys.ACCESS_TOKEN);
    return token || null;
  } catch (error) {
    console.error('获取本地token失败:', error);
    return null;
  }
}

/**
 * 处理登录成功后的跳转
 * @param redirectUrl 重定向URL（可选）
 */
export function handleLoginSuccess(redirectUrl?: string): void {
  if (redirectUrl) {
    // 如果有重定向URL，则跳转到指定页面
    wx.redirectTo({
      url: redirectUrl,
      fail: () => {
        // 如果跳转失败，则回到首页
        wx.switchTab({ url: '/pages/home/index' });
      }
    });
  } else {
    // 默认跳转到个人中心
    wx.switchTab({
      url: '/pages/my/index',
      fail: () => {
        // 如果跳转失败，则回到首页
        wx.switchTab({ url: '/pages/home/index' });
      }
    });
  }
}

/**
 * 显示API错误消息
 * @param response API响应
 */
export function showApiError(response: ApiResponse<any>): void {
  const message = response.message || '操作失败，请重试';
  wx.showToast({
    title: message,
    icon: 'none',
    duration: 2000
  });
}

/**
 * 显示成功消息
 * @param message 消息内容
 */
export function showSuccess(message: string): void {
  wx.showToast({
    title: message,
    icon: 'success',
    duration: 2000
  });
} 